/**
 * 标签页会话管理器 - 后台脚本
 * 处理标签页的保存和恢复功能
 */

// 保存当前所有标签页
function saveCurrentSession(sessionName) {
  return new Promise((resolve, reject) => {
    try {
      // 获取当前窗口的所有标签页
      chrome.tabs.query({}, tabs => {
        // 提取需要保存的标签页信息，跳过以about:开头的标签页
        const tabsData = tabs
          .filter(tab => !tab.url.startsWith("about:"))
          .map(tab => ({
            url: tab.url,
            title: tab.title,
            favIconUrl: tab.favIconUrl,
          }));

        // 如果过滤后没有标签页，提示用户
        if (tabsData.length === 0) {
          resolve({
            success: false,
            error: "没有可保存的标签页（已跳过浏览器内部页面）",
          });
          return;
        }

        // 获取当前已保存的会话
        chrome.storage.local.get("sessions", result => {
          const sessions = result.sessions || {};

          // 添加新会话，使用时间戳作为默认名称
          const timestamp = new Date().toISOString();
          const name = sessionName || `${new Date().toLocaleString()}`;

          sessions[timestamp] = {
            name: name,
            tabs: tabsData,
            createdAt: timestamp,
          };

          // 保存更新后的会话数据
          chrome.storage.local.set({ sessions }, () => {
            if (chrome.runtime.lastError) {
              console.error("保存会话失败:", chrome.runtime.lastError);
              resolve({
                success: false,
                error: chrome.runtime.lastError.message,
              });
            } else {
              resolve({ success: true, sessionId: timestamp });
            }
          });
        });
      });
    } catch (error) {
      console.error("保存会话失败:", error);
      resolve({ success: false, error: error.message });
    }
  });
}

// 获取所有保存的会话
function getAllSessions() {
  return new Promise((resolve, reject) => {
    try {
      chrome.storage.local.get("sessions", result => {
        if (chrome.runtime.lastError) {
          console.error("获取会话失败:", chrome.runtime.lastError);
          resolve({ success: false, error: chrome.runtime.lastError.message });
        } else {
          const sessions = result.sessions || {};
          resolve({ success: true, sessions });
        }
      });
    } catch (error) {
      console.error("获取会话失败:", error);
      resolve({ success: false, error: error.message });
    }
  });
}

// 恢复指定的会话
function restoreSession(sessionId) {
  return new Promise((resolve, reject) => {
    try {
      // 获取所有保存的会话
      chrome.storage.local.get("sessions", result => {
        const sessions = result.sessions || {};

        // 检查会话是否存在
        if (!sessions[sessionId]) {
          console.error("会话不存在");
          resolve({ success: false, error: "会话不存在" });
          return;
        }

        const session = sessions[sessionId];

        // 检查会话中是否有标签页
        if (!session.tabs || session.tabs.length === 0) {
          console.warn("会话中没有标签页");
          resolve({ success: true, message: "会话中没有标签页" });
          return;
        }

        // 获取当前窗口
        chrome.windows.getCurrent(currentWindow => {
          const windowId = currentWindow.id;

          // 获取当前窗口中所有标签页的URL
          chrome.tabs.query({ windowId }, existingTabs => {
            const existingUrls = new Set(existingTabs.map(tab => tab.url));

            console.log(`在当前窗口(ID: ${windowId})中恢复会话`);

            let createdCount = 0;
            let skippedCount = 0;

            // 准备要创建的标签页列表（过滤掉已存在的）
            const tabsToCreate = session.tabs.filter(
              tab => !existingUrls.has(tab.url)
            );

            console.log(
              `将创建${tabsToCreate.length}个标签页，跳过${
                session.tabs.length - tabsToCreate.length
              }个已存在的标签页`
            );
            skippedCount = session.tabs.length - tabsToCreate.length;

            // 如果没有需要创建的标签页，直接返回
            if (tabsToCreate.length === 0) {
              resolve({
                success: true,
                message: `已恢复0个标签页，跳过${skippedCount}个已存在的标签页`,
              });
              return;
            }

            // 创建标签页并计数
            let completedCount = 0;
            for (const tab of tabsToCreate) {
              chrome.tabs.create(
                {
                  url: tab.url,
                  windowId: windowId,
                },
                newTab => {
                  completedCount++;
                  if (newTab) {
                    console.log(`已创建标签页: ${tab.url}`);
                    createdCount++;
                  } else {
                    console.warn(`创建标签页失败: URL: ${tab.url}`);
                  }

                  // 当所有标签页都处理完毕时，返回结果
                  if (completedCount === tabsToCreate.length) {
                    resolve({
                      success: true,
                      message: `已恢复${createdCount}个标签页，跳过${skippedCount}个已存在的标签页`,
                    });
                  }
                }
              );
            }
          });
        });
      });
    } catch (error) {
      console.error("恢复会话失败:", error);
      resolve({ success: false, error: error.message });
    }
  });
}

// 删除指定的会话
function deleteSession(sessionId) {
  return new Promise((resolve, reject) => {
    try {
      // 获取所有保存的会话
      chrome.storage.local.get("sessions", result => {
        const sessions = result.sessions || {};

        // 检查会话是否存在
        if (!sessions[sessionId]) {
          console.error("会话不存在");
          resolve({ success: false, error: "会话不存在" });
          return;
        }

        // 删除会话
        delete sessions[sessionId];

        // 保存更新后的会话数据
        chrome.storage.local.set({ sessions }, () => {
          if (chrome.runtime.lastError) {
            console.error("删除会话失败:", chrome.runtime.lastError);
            resolve({
              success: false,
              error: chrome.runtime.lastError.message,
            });
          } else {
            resolve({ success: true });
          }
        });
      });
    } catch (error) {
      console.error("删除会话失败:", error);
      resolve({ success: false, error: error.message });
    }
  });
}

// 编辑指定的会话
function editSession(sessionId, sessionData) {
  return new Promise((resolve, reject) => {
    try {
      // 获取所有保存的会话
      chrome.storage.local.get("sessions", result => {
        const sessions = result.sessions || {};

        // 检查会话是否存在
        if (!sessions[sessionId]) {
          console.error("会话不存在");
          resolve({ success: false, error: "会话不存在" });
          return;
        }

        // 更新会话数据，保留原始创建时间和标签页数据
        sessions[sessionId] = {
          ...sessions[sessionId],
          name: sessionData.name || sessions[sessionId].name,
          // 如果提供了新的标签页数据，则使用新数据
          tabs: sessionData.tabs || sessions[sessionId].tabs,
        };

        // 保存更新后的会话数据
        chrome.storage.local.set({ sessions }, () => {
          if (chrome.runtime.lastError) {
            console.error("编辑会话失败:", chrome.runtime.lastError);
            resolve({
              success: false,
              error: chrome.runtime.lastError.message,
            });
          } else {
            resolve({ success: true });
          }
        });
      });
    } catch (error) {
      console.error("编辑会话失败:", error);
      resolve({ success: false, error: error.message });
    }
  });
}

// 监听来自popup的消息
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  switch (message.action) {
    case "saveSession":
      saveCurrentSession(message.sessionName).then(sendResponse);
      return true; // 异步响应

    case "getAllSessions":
      getAllSessions().then(sendResponse);
      return true;

    case "restoreSession":
      restoreSession(message.sessionId).then(sendResponse);
      return true;

    case "deleteSession":
      deleteSession(message.sessionId).then(sendResponse);
      return true;

    case "editSession":
      editSession(message.sessionId, message.sessionData).then(sendResponse);
      return true;
  }
});
